package strategy;

import java.util.Comparator;

/**
 * 通过创建不同的比较策略对同一个物种进行不同的策略比较
 * 相比 comparable 的 CompareTo 需要擦出重写 Comparator 只需要扩展。
 *
 * 策略模式一定要考虑到将来需要扩展的特性。
 */
class StrategyCat implements Comparator<Cat>{

    @Override
    public int compare(Cat o1, Cat o2) {
        return o1.width > o2.width ? 1 : 0;
    }
}

class StrategyDog implements Comparator<Dog>{

    @Override
    public int compare(Dog o1, Dog o2) {
        return o1.height > o2.height ? 1 : 0;
    }
}


class StrategySort<T> {
    public T [] sort(T [] arr, Comparator<T> comparator){
        for (int x = 0; x < arr.length - 1; x++) {//控制外循环次数
            for (int y = 0; y < arr.length - 1 - x; y++) {//-1是为了避免角标越界异常，-x是为了减少外循环次数
                if (comparator.compare(arr[y], arr[y + 1]) > 0) {//判断两个相邻元素的大小
                    swap(arr, y, y + 1);
                }
            }
        }
        return arr;
    }
    public void swap(T [] arr, int a, int b){
        T temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}


public class CompartorIfm {
    public static void main(String[] args) {
        System.out.println("main");

        // 实例化猫的组
        Cat [] cats = new Cat[]{
                new Cat(1,2),
                new Cat(0,1),
                new Cat(-3,1)
        };

        // 实例化猫策略
        StrategyCat strategyCat = new StrategyCat();

        // 实例化排序 要对猫排序
        new StrategySort<Cat>().sort(cats, strategyCat);

        for (Cat cat:cats){
            System.out.println(cat);
        }

        System.out.println("--------------");

        Dog [] dogs = new Dog[]{
                new Dog(1,99),
                new Dog(1,3),
                new Dog(3,-2)
        };

        new StrategySort<Dog>().sort(dogs, (o1,o2)->{
            return o1.height > o2.height ? 1 : 0;
        });

        for (Dog dog:dogs){
            System.out.println(dog);
        }
    }
}
